"""
__S2S_clean_MDL.py_____________________________________________________

Automatically generated AToM3 Model File (Do not modify directly)
Author: levi
Modified: Fri Dec 21 18:55:44 2012
_______________________________________________________________________
"""
from stickylink import *
from widthXfillXdecoration import *
from Station_S import *
from Male_S import *
from Female_S import *
from MatchModel import *
from ApplyModel import *
from Station_T import *
from Male_T import *
from Female_T import *
from match_contains import *
from apply_contains import *
from graph_Female_T import *
from graph_MatchModel import *
from graph_apply_contains import *
from graph_Station_T import *
from graph_Station_S import *
from graph_match_contains import *
from graph_Male_T import *
from graph_Female_S import *
from graph_ApplyModel import *
from graph_Male_S import *
from ATOM3Enum import *
from ATOM3String import *
from ATOM3BottomType import *
from ATOM3Constraint import *
from ATOM3Attribute import *
from ATOM3Float import *
from ATOM3List import *
from ATOM3Link import *
from ATOM3Connection import *
from ATOM3Boolean import *
from ATOM3Appearance import *
from ATOM3Text import *
from ATOM3Action import *
from ATOM3Integer import *
from ATOM3Port import *
from ATOM3MSEnum import *

def S2S_clean_MDL(self, rootNode, SimpleDSLTransMMRootNode=None):

    # --- Generating attributes code for ASG SimpleDSLTransMM ---
    if( SimpleDSLTransMMRootNode ): 
        # author
        SimpleDSLTransMMRootNode.author.setValue('Annonymous')

        # description
        SimpleDSLTransMMRootNode.description.setValue('\n')
        SimpleDSLTransMMRootNode.description.setHeight(15)

        # name
        SimpleDSLTransMMRootNode.name.setValue('S2S_clean')
    # --- ASG attributes over ---


    self.obj30=Station_S(self)
    self.obj30.isGraphObjectVisual = True

    if(hasattr(self.obj30, '_setHierarchicalLink')):
      self.obj30._setHierarchicalLink(False)

    # name
    self.obj30.name.setValue('s')

    self.obj30.graphClass_= graph_Station_S
    if self.genGraphics:
       new_obj = graph_Station_S(620.0,260.0,self.obj30)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Station_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj30.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj30)
    self.globalAndLocalPostcondition(self.obj30, rootNode)
    self.obj30.postAction( rootNode.CREATE )

    self.obj37=Male_S(self)
    self.obj37.isGraphObjectVisual = True

    if(hasattr(self.obj37, '_setHierarchicalLink')):
      self.obj37._setHierarchicalLink(False)

    # name
    self.obj37.name.setValue('m')

    self.obj37.graphClass_= graph_Male_S
    if self.genGraphics:
       new_obj = graph_Male_S(820.0,260.0,self.obj37)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Male_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj37.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj37)
    self.globalAndLocalPostcondition(self.obj37, rootNode)
    self.obj37.postAction( rootNode.CREATE )

    self.obj38=Female_S(self)
    self.obj38.isGraphObjectVisual = True

    if(hasattr(self.obj38, '_setHierarchicalLink')):
      self.obj38._setHierarchicalLink(False)

    # name
    self.obj38.name.setValue('f')

    self.obj38.graphClass_= graph_Female_S
    if self.genGraphics:
       new_obj = graph_Female_S(1000.0,260.0,self.obj38)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Female_S", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj38.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj38)
    self.globalAndLocalPostcondition(self.obj38, rootNode)
    self.obj38.postAction( rootNode.CREATE )

    self.obj31=MatchModel(self)
    self.obj31.isGraphObjectVisual = True

    if(hasattr(self.obj31, '_setHierarchicalLink')):
      self.obj31._setHierarchicalLink(False)

    self.obj31.graphClass_= graph_MatchModel
    if self.genGraphics:
       new_obj = graph_MatchModel(360.0,200.0,self.obj31)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("MatchModel", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj31.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj31)
    self.globalAndLocalPostcondition(self.obj31, rootNode)
    self.obj31.postAction( rootNode.CREATE )

    self.obj32=ApplyModel(self)
    self.obj32.isGraphObjectVisual = True

    if(hasattr(self.obj32, '_setHierarchicalLink')):
      self.obj32._setHierarchicalLink(False)

    self.obj32.graphClass_= graph_ApplyModel
    if self.genGraphics:
       new_obj = graph_ApplyModel(360.0,440.0,self.obj32)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("ApplyModel", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj32.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj32)
    self.globalAndLocalPostcondition(self.obj32, rootNode)
    self.obj32.postAction( rootNode.CREATE )

    self.obj33=Station_T(self)
    self.obj33.isGraphObjectVisual = True

    if(hasattr(self.obj33, '_setHierarchicalLink')):
      self.obj33._setHierarchicalLink(False)

    # name
    self.obj33.name.setValue('s')

    self.obj33.graphClass_= graph_Station_T
    if self.genGraphics:
       new_obj = graph_Station_T(620.0,520.0,self.obj33)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Station_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj33.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj33)
    self.globalAndLocalPostcondition(self.obj33, rootNode)
    self.obj33.postAction( rootNode.CREATE )

    self.obj39=Male_T(self)
    self.obj39.isGraphObjectVisual = True

    if(hasattr(self.obj39, '_setHierarchicalLink')):
      self.obj39._setHierarchicalLink(False)

    # name
    self.obj39.name.setValue('m')

    self.obj39.graphClass_= graph_Male_T
    if self.genGraphics:
       new_obj = graph_Male_T(820.0,520.0,self.obj39)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Male_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj39.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj39)
    self.globalAndLocalPostcondition(self.obj39, rootNode)
    self.obj39.postAction( rootNode.CREATE )

    self.obj40=Female_T(self)
    self.obj40.isGraphObjectVisual = True

    if(hasattr(self.obj40, '_setHierarchicalLink')):
      self.obj40._setHierarchicalLink(False)

    # name
    self.obj40.name.setValue('f')

    self.obj40.graphClass_= graph_Female_T
    if self.genGraphics:
       new_obj = graph_Female_T(1000.0,520.0,self.obj40)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("Female_T", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
       new_obj.layConstraints['scale'] = [1.0, 1.0]
    else: new_obj = None
    self.obj40.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj40)
    self.globalAndLocalPostcondition(self.obj40, rootNode)
    self.obj40.postAction( rootNode.CREATE )

    self.obj34=match_contains(self)
    self.obj34.isGraphObjectVisual = True

    if(hasattr(self.obj34, '_setHierarchicalLink')):
      self.obj34._setHierarchicalLink(False)

    self.obj34.graphClass_= graph_match_contains
    if self.genGraphics:
       new_obj = graph_match_contains(551.0,271.0,self.obj34)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("match_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj34.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj34)
    self.globalAndLocalPostcondition(self.obj34, rootNode)
    self.obj34.postAction( rootNode.CREATE )

    self.obj41=match_contains(self)
    self.obj41.isGraphObjectVisual = True

    if(hasattr(self.obj41, '_setHierarchicalLink')):
      self.obj41._setHierarchicalLink(False)

    self.obj41.graphClass_= graph_match_contains
    if self.genGraphics:
       new_obj = graph_match_contains(651.0,271.0,self.obj41)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("match_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj41.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj41)
    self.globalAndLocalPostcondition(self.obj41, rootNode)
    self.obj41.postAction( rootNode.CREATE )

    self.obj42=match_contains(self)
    self.obj42.isGraphObjectVisual = True

    if(hasattr(self.obj42, '_setHierarchicalLink')):
      self.obj42._setHierarchicalLink(False)

    self.obj42.graphClass_= graph_match_contains
    if self.genGraphics:
       new_obj = graph_match_contains(741.0,271.0,self.obj42)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("match_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj42.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj42)
    self.globalAndLocalPostcondition(self.obj42, rootNode)
    self.obj42.postAction( rootNode.CREATE )

    self.obj35=apply_contains(self)
    self.obj35.isGraphObjectVisual = True

    if(hasattr(self.obj35, '_setHierarchicalLink')):
      self.obj35._setHierarchicalLink(False)

    self.obj35.graphClass_= graph_apply_contains
    if self.genGraphics:
       new_obj = graph_apply_contains(553.5,521.0,self.obj35)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("apply_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj35.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj35)
    self.globalAndLocalPostcondition(self.obj35, rootNode)
    self.obj35.postAction( rootNode.CREATE )

    self.obj43=apply_contains(self)
    self.obj43.isGraphObjectVisual = True

    if(hasattr(self.obj43, '_setHierarchicalLink')):
      self.obj43._setHierarchicalLink(False)

    self.obj43.graphClass_= graph_apply_contains
    if self.genGraphics:
       new_obj = graph_apply_contains(653.5,521.0,self.obj43)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("apply_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj43.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj43)
    self.globalAndLocalPostcondition(self.obj43, rootNode)
    self.obj43.postAction( rootNode.CREATE )

    self.obj44=apply_contains(self)
    self.obj44.isGraphObjectVisual = True

    if(hasattr(self.obj44, '_setHierarchicalLink')):
      self.obj44._setHierarchicalLink(False)

    self.obj44.graphClass_= graph_apply_contains
    if self.genGraphics:
       new_obj = graph_apply_contains(743.5,521.0,self.obj44)
       new_obj.DrawObject(self.UMLmodel)
       self.UMLmodel.addtag_withtag("apply_contains", new_obj.tag)
       new_obj.layConstraints = dict() # Graphical Layout Constraints 
    else: new_obj = None
    self.obj44.graphObject_ = new_obj

    # Add node to the root: rootNode
    rootNode.addNode(self.obj44)
    self.globalAndLocalPostcondition(self.obj44, rootNode)
    self.obj44.postAction( rootNode.CREATE )

    # Connections for obj30 (graphObject_: Obj0) named s
    self.drawConnections(
 )
    # Connections for obj37 (graphObject_: Obj7) named m
    self.drawConnections(
 )
    # Connections for obj38 (graphObject_: Obj8) named f
    self.drawConnections(
 )
    # Connections for obj31 (graphObject_: Obj1) of type MatchModel
    self.drawConnections(
(self.obj31,self.obj34,[421.0, 241.0, 551.0, 271.0],"true", 2),
(self.obj31,self.obj41,[421.0, 241.0, 651.0, 271.0],"true", 0),
(self.obj31,self.obj42,[421.0, 241.0, 741.0, 271.0],"true", 0) )
    # Connections for obj32 (graphObject_: Obj2) of type ApplyModel
    self.drawConnections(
(self.obj32,self.obj35,[426.0, 481.0, 553.5, 521.0],"true", 2),
(self.obj32,self.obj43,[426.0, 481.0, 653.5, 521.0],"true", 0),
(self.obj32,self.obj44,[426.0, 481.0, 743.5, 521.0],"true", 0) )
    # Connections for obj33 (graphObject_: Obj3) named s
    self.drawConnections(
 )
    # Connections for obj39 (graphObject_: Obj9) named m
    self.drawConnections(
 )
    # Connections for obj40 (graphObject_: Obj10) named f
    self.drawConnections(
 )
    # Connections for obj34 (graphObject_: Obj4) of type match_contains
    self.drawConnections(
(self.obj34,self.obj30,[551.0, 271.0, 681.0, 301.0],"true", 2) )
    # Connections for obj41 (graphObject_: Obj11) of type match_contains
    self.drawConnections(
(self.obj41,self.obj37,[651.0, 271.0, 881.0, 301.0],"true", 2) )
    # Connections for obj42 (graphObject_: Obj12) of type match_contains
    self.drawConnections(
(self.obj42,self.obj38,[741.0, 271.0, 1061.0, 301.0],"true", 2) )
    # Connections for obj35 (graphObject_: Obj5) of type apply_contains
    self.drawConnections(
(self.obj35,self.obj33,[553.5, 521.0, 681.0, 561.0],"true", 2) )
    # Connections for obj43 (graphObject_: Obj13) of type apply_contains
    self.drawConnections(
(self.obj43,self.obj39,[653.5, 521.0, 881.0, 561.0],"true", 2) )
    # Connections for obj44 (graphObject_: Obj14) of type apply_contains
    self.drawConnections(
(self.obj44,self.obj40,[743.5, 521.0, 1061.0, 561.0],"true", 2) )

newfunction = S2S_clean_MDL

loadedMMName = 'SimpleDSLTransMM_META'

atom3version = '0.3'
